package com.object_.oriented_.super_;

public class SuperA {
    public static void main(String[] args) {
        B b = new B();
        b.sum();

    }
}

class A {
    public int a;
    protected int b;
    int c;
    private int d;

    //无参构造数
    public A() {
        System.out.println("无参构造数");
    }

    //有参构造数
    public A(String name) {
        System.out.println("名字 " + name);
    }

    //有参构造数
    public A(String name, int age) {
        System.out.println("名字 " + name + " 年龄 " + age);
    }

    public void test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {

    }

    public void cal() {
        System.out.println("我是父类的 cal() 方法");
    }
}


class B extends A {
    public void say() {
        //可以访问父类的属性，但不能访问父类的private属性  super.属性名
        System.out.println(super.a);
        System.out.println(super.b);
        System.out.println(super.c);
        //System.out.println(super.d);
        //访问父类的方法，不能访问父类的private方法 super.方法名(参数列表)
        super.test100();
        super.test200();
        super.test300();
        //super.test400(); //不能访问父类的private方法
    }

    //访问父类的构造器：super(参数列表)；只能放在构造器的第一句，只能出现一句
    public B() {
        //super();
        //super("lucy");
        super("lucy", 20);
    }

    /*public test(){
        super();
    }*/

    public void sum() {
        System.out.println("我是子类的sum()方法");
        //三种方法调用父类的方法
        //找 cal方法的，顺序是
        // (1)先找本类，有，并可以调用则调用。
        // (2)如果没有，则找父类(如果有，并可以调用，则调用)
        // (3)如果父类没有，则继续找父类的父类，整个规则都是一样的。
        // 提示：如果查找方法的过程中，找到了，但是benign访问，则报错
        //      如果查找方法的过程中，没有找到，则提示方法不存在。
        cal();
        //跳过本类，直接查找父类
        super.cal();
        this.cal();
    }

    public void cal() {
        System.out.println("我是子类cal()方法");
    }
}
